{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/gavincyi/tf-quant-finance/blob/feature%2Fswap_curve_fitting_example/tf_quant_finance/examples/jupyter_notebooks/Swap_Curve_Fitting.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "EheA5_j_cEwc"
   },
   "source": [
    "##### Copyright 2020 Google LLC.\n",
    "\n",
    "Licensed under the Apache License, Version 2.0 (the \"License\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "YCriMWd-pRTP"
   },
   "outputs": [],
   "source": [
    "#@title Licensed under the Apache License, Version 2.0 (the \"License\"); { display-mode: \"form\" }\n",
    "# you may not use this file except in compliance with the License.\n",
    "# You may obtain a copy of the License at\n",
    "#\n",
    "# https://www.apache.org/licenses/LICENSE-2.0\n",
    "#\n",
    "# Unless required by applicable law or agreed to in writing, software\n",
    "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
    "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
    "# See the License for the specific language governing permissions and\n",
    "# limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OvRwFTkqcp1e"
   },
   "source": [
    "# Swap curve fitting in TensorFlow Quant Finance (TFF)\n",
    "\n",
    "TensorFlow Finance has built-in library for unconstrained numerical optimization. This notebook shows how to use it.\n",
    "\n",
    "<table class=\"tfo-notebook-buttons\" align=\"left\">\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/google/tf-quant-finance/blob/master/tf_quant_finance/examples/jupyter_notebooks/Swap_Curve_Fitting.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
    "  </td>\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://github.com/google/tf-quant-finance/blob/master/tf_quant_finance/examples/jupyter_notebooks/Swap_Curve_Fitting.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "both",
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 479
    },
    "colab_type": "code",
    "id": "uG8UAZXjeUhf",
    "outputId": "ab5bbaab-b39c-4953-903f-13c636a937a6"
   },
   "outputs": [],
   "source": [
    "#@title Install TF Quant Finance\n",
    "!pip install 'tensorflow>=2.1.0'\n",
    "!pip install tf-quant-finance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "xmqzltQrwcDt"
   },
   "outputs": [],
   "source": [
    "#@title Imports\n",
    "from datetime import datetime\n",
    "\n",
    "import tensorflow as tf\n",
    "import tensorflow_probability as tfp\n",
    "import functools\n",
    "import matplotlib.colors as colors\n",
    "\n",
    "import tf_quant_finance as tff\n",
    "import tf_quant_finance.experimental.dates as dates\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "from IPython.core.pylabtools import figsize\n",
    "\n",
    "# Import seaborn if you want to have fancy visualization\n",
    "# import seaborn as sns\n",
    "# sns.set(style=\"darkgrid\")\n",
    "\n",
    "figsize(12, 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build instrument cashflows"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following functions are used to build the cashflows on the fixed and floating legs for curve fitting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Cash instruments\n",
    "\n",
    "Cash instruments generate the cashflow by simple spot rate, i.e.\n",
    "\n",
    "$$[1 + R \\cdot \\tau] \\cdot DF(\\tau) = 1$$\n",
    "\n",
    "where $\\tau$ is the tenor of the instrument, $R$ is the market rate and $DF(\\tau)$ is the discount factor at time $\\tau$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title 1. Cash instruments\n",
    "def build_spot_cash_instrument(tenor, close, dtype, **kwargs):\n",
    "    \"\"\"Build spot cash instrument.\n",
    "    \n",
    "    Args:\n",
    "      tenor: `dates.PeriodTensor`. Defined the tenor of the floating rate.     \n",
    "      close: `float64`. Defined the close rate of the instrument.\n",
    "        \n",
    "    Returns:\n",
    "      A `dict` containing the inputs for swap_curve_fit, e.g. \n",
    "      `float_leg_start_time`.\n",
    "    \"\"\"\n",
    "    assert tenor.period_type() == dates.PeriodType.MONTH\n",
    "    tenor = tenor.quantity().numpy() / 12.0\n",
    "    return {\n",
    "        'float_leg_start_time': tf.constant([0.0], dtype=dtype),\n",
    "        'float_leg_end_time': tf.constant([tenor], dtype=dtype),\n",
    "        'float_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
    "        'fixed_leg_start_time': tf.constant([0.0], dtype=dtype),\n",
    "        'fixed_leg_end_time': tf.constant([tenor], dtype=dtype),\n",
    "        'fixed_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
    "        'fixed_leg_cashflow': tf.constant([-close], dtype=dtype),\n",
    "        'pv': 0.0,\n",
    "        'initial_curve_rate': 1e-6,\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Forward and Future instruments\n",
    "\n",
    "Forward instruments, similar to cash instruments, generate the cashflow by simple spot rate on a specified forward date, i.e.\n",
    "\n",
    "$$[1 + R \\cdot \\tau(t_1, t_2)] \\cdot DF(t_2) - DF(t_1) = 0$$\n",
    "\n",
    "where $t_1$ is the forward start time, $t_2$ is the maturity time, $\\tau(t_1, t_2)$ is the tenor of the instrument, and R is the market rate.\n",
    "\n",
    "The difference between the forward and future rates is the convexity adjustment. Since the difference is minimal for instrument less then 2Y maturity, it is assumed to be the same for simplicity here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title 2. Forward and Future instruments\n",
    "def build_futures_instrument(        \n",
    "        settle_date, maturity_date, close, tenor, dtype, **kwargs):\n",
    "    \"\"\"Build futures instrument.\n",
    "    \n",
    "    Args:\n",
    "      settle_date: `datetime.datetime`. Defines the date when the instrument\n",
    "        is settled.\n",
    "      maturity_date: `datetime.datetime`. Defines the maturity date of the \n",
    "        instrument.\n",
    "      close: `float64`. Defined the close rate of the instrument.\n",
    "      tenor: `dates.PeriodTensor`. Defined the tenor of the floating rate.       \n",
    "        \n",
    "    Returns:\n",
    "      A `dict` containing the inputs for swap_curve_fit, e.g. \n",
    "      `float_leg_start_time`.\n",
    "    \"\"\"\n",
    "    assert tenor.period_type() == dates.PeriodType.MONTH\n",
    "    tenor = tenor.quantity().numpy() / 12.0\n",
    "    \n",
    "    start = daycount(\n",
    "        start_date=dates.from_datetimes([settle_date]),\n",
    "        end_date=dates.from_datetimes([maturity_date]),\n",
    "        dtype=dtype\n",
    "    )\n",
    "    \n",
    "    return {\n",
    "        'float_leg_start_time': start,\n",
    "        'float_leg_end_time': start + tenor,\n",
    "        'float_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
    "        'fixed_leg_start_time': start,\n",
    "        'fixed_leg_end_time': start + tenor,\n",
    "        'fixed_leg_daycount': tf.constant([tenor], dtype=dtype),\n",
    "        'fixed_leg_cashflow': tf.constant([-close], dtype=dtype),\n",
    "        'pv': 0.0,\n",
    "        'initial_curve_rate': 1e-6,\n",
    "    }    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Swap instruments\n",
    "\n",
    "Given a pre-defined notional principal $K$, the present value of the fixed leg can be expressed as\n",
    "\n",
    "$$ PV(fixed) = \\sum_{i=1}^{N_{fixed}} [K \\cdot R \\cdot \\tau(i) \\cdot DF(t_i)] + K \\cdot DF(t_{N_{fixed}}) $$\n",
    "\n",
    "where $R$ is the market rate, $N_{fixed}$ is the total number of fixed leg payments, $\\tau(i)$ is the day count fraction that determines the $i^{th}$ payment amount, $DF(t_1)$ is the discount factor at $i^{th}$ payment time t. \n",
    "\n",
    "Same for the present value of the floating leg\n",
    "\n",
    "$$ PV(floating) = \\sum_{i=1}^{N_{floating}} [K \\cdot R(i) \\cdot \\tau(i) \\cdot DF(t_i)] + K \\cdot DF(t_{N_{floating}}) $$\n",
    "\n",
    "where $R(i)$ is an effective rate to cover $i^{th}$ payment on the floating leg.\n",
    "\n",
    "Under the no-arbitrage rule, the present value of the fixed and floating leg must be equal, i.e.\n",
    "\n",
    "$$ PV(fixed) = PV(floating) $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#@title 3. Swap instruments\n",
    "def build_swap_instrument(\n",
    "        settle_date, maturity_date, close, fixed_tenor, float_tenor, daycount,\n",
    "        roll_convention, dtype, **kwargs):\n",
    "    \"\"\"Build futures instrument.\n",
    "    \n",
    "    Args:\n",
    "      settle_date: `datetime.datetime`. Defines the date when the instrument\n",
    "        is settled.\n",
    "      maturity_date: `datetime.datetime`. Defines the maturity date of the \n",
    "        instrument.\n",
    "      close: `float64`. Defined the close rate of the instrument.\n",
    "      fixed_tenor: `float64`. Defined the tenor of the fixed rate.\n",
    "      float_tenor: `float64`. Defined the tenor of the floating rate.\n",
    "      daycount: `callable`. Defines the daycount convention function imported\n",
    "          from `dates.daycounts`.\n",
    "      roll_convention: `dates.BusinessDayConvention`. Defines the roll\n",
    "          convention.\n",
    "      dtype: `tf.Dtype`. If supplied the dtype for the (elements of)\n",
    "        `float_leg_start_times`, and `fixed_leg_start_times`.\n",
    "        Default value: None which maps to the default dtype inferred by\n",
    "        TensorFlow.   \n",
    "          \n",
    "    Returns:\n",
    "      A `dict` containing the inputs for swap_curve_fit, e.g. \n",
    "      `float_leg_start_time`.\n",
    "    \"\"\"    \n",
    "    settle_date = dates.from_datetimes([settle_date])\n",
    "    maturity_date = dates.from_datetimes([maturity_date])\n",
    "    float_leg_dates = dates.PeriodicSchedule(\n",
    "        start_date=settle_date,\n",
    "        end_date=maturity_date,\n",
    "        tenor=float_tenor,\n",
    "        roll_convention=roll_convention,\n",
    "        backward=False).dates()[0]  \n",
    "    fixed_leg_dates = dates.PeriodicSchedule(\n",
    "        start_date=settle_date,\n",
    "        end_date=maturity_date,\n",
    "        tenor=fixed_tenor,\n",
    "        roll_convention=roll_convention,\n",
    "        backward=False).dates()[0]          \n",
    "        \n",
    "    return {\n",
    "        'float_leg_start_time': daycount(\n",
    "            start_date=settle_date, \n",
    "            end_date=float_leg_dates[:-1],\n",
    "            dtype=dtype),\n",
    "        'float_leg_end_time': daycount(\n",
    "            start_date=settle_date, \n",
    "            end_date=float_leg_dates[1:],\n",
    "            dtype=dtype),\n",
    "        'float_leg_daycount': daycount(\n",
    "            start_date=float_leg_dates[:-1],\n",
    "            end_date=float_leg_dates[1:],\n",
    "            dtype=dtype),\n",
    "        'fixed_leg_start_time': daycount(\n",
    "            start_date=settle_date, \n",
    "            end_date=fixed_leg_dates[:-1],\n",
    "            dtype=dtype),\n",
    "        'fixed_leg_end_time': daycount(\n",
    "            start_date=settle_date, \n",
    "            end_date=fixed_leg_dates[1:],\n",
    "            dtype=dtype),\n",
    "        'fixed_leg_daycount': daycount(\n",
    "            start_date=fixed_leg_dates[:-1],\n",
    "            end_date=fixed_leg_dates[1:],\n",
    "            dtype=dtype),\n",
    "        'fixed_leg_cashflow': tf.repeat(\n",
    "            tf.constant(-close, dtype=dtype), \n",
    "            repeats=fixed_leg_dates.shape[0] - 1, \n",
    "        ),\n",
    "        'pv': 0.0,\n",
    "        'initial_curve_rate': 1e-6,\n",
    "    }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fit the interest rate curve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The data is retrieved from Bloomberg on 2020-02-14 to fit the USD LIBOR 3M curve. \n",
    "\n",
    "The following market instruments are used\n",
    "\n",
    "- LIBOR Fixed 3 Month: Spot LIBOR 3M rate\n",
    "\n",
    "- ED Futures: Eurodollar Futures with expiry up to 2Y\n",
    "\n",
    "- Interest Rate Swap: Liquid interest rate swap instruments with tenors from 2 years to 50 years"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "float_leg_start_times = []\n",
    "float_leg_end_times = []\n",
    "float_leg_daycounts = []\n",
    "fixed_leg_start_times = []\n",
    "fixed_leg_end_times = []\n",
    "fixed_leg_daycounts = []\n",
    "fixed_leg_cashflows = []\n",
    "pvs = []\n",
    "initial_curve_rates = []\n",
    "\n",
    "# Global dtype\n",
    "dtype = tf.float64\n",
    "\n",
    "# Global daycount - Fit on USD curve\n",
    "daycount = tff.experimental.dates.daycounts.actual_360\n",
    "\n",
    "# Global roll convention - Backward\n",
    "roll_convention = dates.BusinessDayConvention.PRECEDING\n",
    "\n",
    "# The fixed leg payment frequency is 6M\n",
    "fixed_tenor = dates.periods.months(6)\n",
    "\n",
    "# The floating rate is always USD LIBOR 3M\n",
    "float_tenor = dates.periods.months(3)\n",
    "\n",
    "instruments = [\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2020-05-21', \n",
    "     'close': 0.01696000000, 'name': 'USD3MD'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2020-06-17', \n",
    "     'close': 0.01669900000, 'name': 'EDH0'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2020-09-16', \n",
    "     'close': 0.01544400000, 'name': 'EDM0'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2020-12-16', \n",
    "     'close': 0.01468600000, 'name': 'EDU0'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2021-03-17', \n",
    "     'close': 0.01427500000, 'name': 'EDZ0'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2021-06-16', \n",
    "     'close': 0.01326200000, 'name': 'EDH1'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2021-09-15', \n",
    "     'close': 0.01299700000, 'name': 'EDM1'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2021-12-15', \n",
    "     'close': 0.01277900000, 'name': 'EDU1'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2022-03-16', \n",
    "     'close': 0.01295900000, 'name': 'EDZ1'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2022-06-15', \n",
    "     'close': 0.01288600000, 'name': 'EDH2'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2022-09-21', \n",
    "     'close': 0.01295900000, 'name': 'EDM2'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2022-12-21', \n",
    "     'close': 0.01308200000, 'name': 'EDU2'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2023-03-15', \n",
    "     'close': 0.01335500000, 'name': 'EDZ2'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2024-02-21', \n",
    "     'close': 0.01378410000, 'name': 'USDAM3L4Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2025-02-21', \n",
    "     'close': 0.01384037500\n",
    "     , 'name': 'USDAM3L6Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2027-02-22', \n",
    "     'close': 0.01419340000, 'name': 'USDAM3L7Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2028-02-22', \n",
    "     'close': 0.01443062500, 'name': 'USDAM3L8Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2029-02-21', \n",
    "     'close': 0.01468025000, 'name': 'USDAM3L9Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2030-02-21', \n",
    "     'close': 0.01494412500, 'name': 'USDAM3L10Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2032-02-23', \n",
    "     'close': 0.01542162500, 'name': 'USDAM3L12Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2035-02-21', \n",
    "     'close': 0.01592825000, 'name': 'USDAM3L15Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2040-02-21', \n",
    "     'close': 0.01644683333, 'name': 'USDAM3L20Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2045-02-21', \n",
    "     'close': 0.01666350000, 'name': 'USDAM3L25Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2050-02-22', \n",
    "     'close': 0.01662650000, 'name': 'USDAM3L30Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2060-02-23', \n",
    "     'close': 0.01613000000, 'name': 'USDAM3L40Y'},\n",
    "    {'settle_date': '2020-02-19', 'maturity_date': '2070-02-21', \n",
    "     'close': 0.01534000000, 'name': 'USDAM3L50Y'},\n",
    "]\n",
    "\n",
    "for instrument in instruments:\n",
    "    instrument['settle_date'] = (\n",
    "        datetime.strptime(instrument['settle_date'], '%Y-%m-%d')\n",
    "    )\n",
    "    instrument['maturity_date'] = (\n",
    "        datetime.strptime(instrument['maturity_date'], '%Y-%m-%d')\n",
    "    )    \n",
    "    if instrument['name'] == 'USD3MD':\n",
    "        # Spot instrument\n",
    "        instrument = build_spot_cash_instrument(\n",
    "            tenor=float_tenor, \n",
    "            dtype=dtype,\n",
    "            **instrument\n",
    "        )\n",
    "    elif instrument['name'][:2] == 'ED':\n",
    "        # Futures instrument\n",
    "        instrument = build_futures_instrument(\n",
    "            dtype=dtype,\n",
    "            tenor=float_tenor, \n",
    "            **instrument\n",
    "        )\n",
    "    elif instrument['name'].startswith('USDAM3L'):\n",
    "        # Swap instrument\n",
    "        instrument = build_swap_instrument(\n",
    "            fixed_tenor=fixed_tenor,\n",
    "            float_tenor=float_tenor,\n",
    "            roll_convention=roll_convention,\n",
    "            daycount=daycount,\n",
    "            dtype=dtype,\n",
    "            **instrument\n",
    "        )\n",
    "    else:\n",
    "        raise NotImplementedError(\n",
    "            'Cannot recognize the type of instrument %s'\n",
    "            % instrument['name']\n",
    "        )\n",
    "    \n",
    "    float_leg_start_times.append(instrument['float_leg_start_time'])\n",
    "    float_leg_end_times.append(instrument['float_leg_end_time'])\n",
    "    float_leg_daycounts.append(instrument['float_leg_daycount'])\n",
    "    fixed_leg_start_times.append(instrument['fixed_leg_start_time'])\n",
    "    fixed_leg_end_times.append(instrument['fixed_leg_end_time'])\n",
    "    fixed_leg_daycounts.append(instrument['fixed_leg_daycount'])\n",
    "    fixed_leg_cashflows.append(instrument['fixed_leg_cashflow'])\n",
    "    pvs.append(instrument['pv'])\n",
    "    initial_curve_rates.append(instrument['initial_curve_rate'])\n",
    "    \n",
    "curve = tff.rates.swap_curve_fit(\n",
    "    float_leg_start_times=float_leg_start_times,\n",
    "    float_leg_end_times=float_leg_end_times,\n",
    "    float_leg_daycount_fractions=float_leg_daycounts,\n",
    "    fixed_leg_start_times=fixed_leg_start_times,\n",
    "    fixed_leg_end_times=fixed_leg_end_times,\n",
    "    fixed_leg_cashflows=fixed_leg_cashflows,\n",
    "    fixed_leg_daycount_fractions=fixed_leg_daycounts,\n",
    "    present_values=tf.constant(pvs, dtype=dtype),\n",
    "    initial_curve_rates=tf.constant(initial_curve_rates, dtype))    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "No handles with labels found to put in legend.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(curve.times, curve.rates)\n",
    "plt.title('Discount Rate Curve', fontsize=20)\n",
    "plt.xlabel('Time', fontsize=18)\n",
    "plt.ylabel('Discount Rate', fontsize=18)\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Reference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[1] Bloomberg, Building the Bloomberg Interest Rate Curve – Definitions and Methodology, Mar 2016"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Swap Curve Fitting.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
